package com.ocean.system.service.impl;

import java.util.ArrayList;
import java.util.List;

import com.ocean.system.domain.OProductDept;
import com.ocean.system.domain.ProductCheckbox;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ocean.common.annotation.DataScope;
import com.ocean.common.constant.UserConstants;
import com.ocean.common.core.domain.Ztree;
import com.ocean.common.core.domain.entity.SysDept;
import com.ocean.common.core.domain.entity.SysRole;
import com.ocean.common.core.domain.entity.SysUser;
import com.ocean.common.core.text.Convert;
import com.ocean.common.exception.ServiceException;
import com.ocean.common.utils.ShiroUtils;
import com.ocean.common.utils.StringUtils;
import com.ocean.common.utils.spring.SpringUtils;
import com.ocean.system.mapper.SysDeptMapper;
import com.ocean.system.service.ISysDeptService;

/**
 * 组织管理 服务实现
 *
 * @author ocean
 */
@Service
public class SysDeptServiceImpl implements ISysDeptService
{
    @Autowired
    private SysDeptMapper deptMapper;

    /**
     * 查询组织管理数据
     *
     * @param dept 组织信息
     * @return 组织信息集合
     */
    @Override
    @DataScope(deptAlias = "d")
    public List<SysDept> selectDeptList(SysDept dept)
    {
        List<SysDept> sysDeptList = deptMapper.selectDeptList(dept);
        for (SysDept sysDept : sysDeptList) {
            if(StringUtils.isNotBlank(sysDept.getIsShow())){
                sysDept.setIsShowInt(Integer.parseInt(sysDept.getIsShow()));
            }
        }
        return sysDeptList;
    }

    /**
     * 查询组织管理树
     *
     * @param dept 组织信息
     * @return 所有组织信息
     */
    @Override
    @DataScope(deptAlias = "d")
    public List<Ztree> selectDeptTree(SysDept dept)
    {
        List<SysDept> deptList = deptMapper.selectDeptList(dept);
        List<Ztree> ztrees = initZtree(deptList);
        return ztrees;
    }

    /**
     * 根据角色ID查询组织（数据权限）
     *
     * @param role 角色对象
     * @return 组织列表（数据权限）
     */
    @Override
    public List<Ztree> roleDeptTreeData(SysRole role)
    {
        Long roleId = role.getRoleId();
        List<Ztree> ztrees = new ArrayList<Ztree>();
        List<SysDept> deptList = SpringUtils.getAopProxy(this).selectDeptList(new SysDept());
        if (StringUtils.isNotNull(roleId))
        {
            List<String> roleDeptList = deptMapper.selectRoleDeptTree(roleId);
            ztrees = initZtree(deptList, roleDeptList);
        }
        else
        {
            ztrees = initZtree(deptList);
        }
        return ztrees;
    }

    /**
     * 对象转组织树
     *
     * @param deptList 组织列表
     * @return 树结构列表
     */
    public List<Ztree> initZtree(List<SysDept> deptList)
    {
        return initZtree(deptList, null);
    }

    /**
     * 对象转组织树
     *
     * @param deptList 组织列表
     * @param roleDeptList 角色已存在菜单列表
     * @return 树结构列表
     */
    public List<Ztree> initZtree(List<SysDept> deptList, List<String> roleDeptList)
    {

        List<Ztree> ztrees = new ArrayList<Ztree>();
        boolean isCheck = StringUtils.isNotNull(roleDeptList);
        for (SysDept dept : deptList)
        {
            if (UserConstants.DEPT_NORMAL.equals(dept.getStatus()))
            {
                Ztree ztree = new Ztree();
                ztree.setId(dept.getDeptId());
                //ztree.setpId(dept.getParentId());
                ztree.setName(dept.getDeptName());
                ztree.setTitle(dept.getDeptName());
                if (isCheck)
                {
                    ztree.setChecked(roleDeptList.contains(dept.getDeptId() + dept.getDeptName()));
                }
                ztrees.add(ztree);
            }
        }
        return ztrees;
    }

    /**
     * 查询组织是否存在用户
     *
     * @param deptId 组织ID
     * @return 结果 true 存在 false 不存在
     */
    @Override
    public boolean checkDeptExistUser(Long deptId)
    {
        int result = deptMapper.checkDeptExistUser(deptId);
        return result > 0;
    }

    /**
     * 删除组织管理信息
     *
     * @param deptId 组织ID
     * @return 结果
     */
    @Override
    public int deleteDeptById(Long deptId)
    {
        // 删除组织数据
        int count = deptMapper.deleteDeptById(deptId);
        // 删除组织产品中间表数据
        deptMapper.deleteProductDept(deptId);
        return count;
    }

    /**
     * 新增保存组织信息
     *
     * @param dept 组织信息
     * @return 结果
     */
    @Override
    public int insertDept(SysDept dept)
    {
        // 声明产品新增数量
        Integer productNumber = 0;
        // 查询表中org_code的最大值,使用最大值+1保存进去
        String orgCode = deptMapper.selectDeptMaxOrgCode();
        if(StringUtils.isNotBlank(orgCode)){
            int orgCodeInt = Integer.parseInt(orgCode) + 1;
            dept.setOrgCode(orgCodeInt + "");
        }
        // 执行新增部门
        productNumber = deptMapper.insertDept(dept);
        // 批量新增产品数据
        batchInsertDepart(dept,productNumber);
        // 返回执行结果
        return productNumber;
    }

    /**
     * 批量新增新增组织产品中间表数据
     * @param dept 组织数据
     */
    private void batchInsertDepart(SysDept dept, Integer productNumber) {
        if(StringUtils.isNotBlank(dept.getProduct()) && null != dept.getDeptId() && productNumber > 0){
            // 创建新增组织产品中间表集合
            List<OProductDept> oProductDeptList = new ArrayList<>();
            // 判断字符串是否包含, 包含就截取
            if(dept.getProduct().contains(",")){
                String[] productIds = dept.getProduct().split(",");
                for (String productId : productIds) {
                    // 创建中间表实体对象
                    OProductDept oProductDept = new OProductDept();
                    oProductDept.setProductId(productId);
                    oProductDept.setDeptId(dept.getDeptId().toString());
                    oProductDeptList.add(oProductDept);
                }
            } else {
                // 创建中间表实体对象
                OProductDept oProductDept = new OProductDept();
                oProductDept.setProductId(dept.getProduct());
                oProductDept.setDeptId(dept.getDeptId().toString());
                oProductDeptList.add(oProductDept);
            }
            // 执行新增组织产品中间表数据
            deptMapper.batchInsertDepart(oProductDeptList);
        }
    }

    /**
     * 修改保存组织信息
     *
     * @param dept 组织信息
     * @return 结果
     */
    @Override
    @Transactional
    public int updateDept(SysDept dept)
    {
        // 声明产品修改数量
        Integer productNumber = 0;
        // 修改组织数据
        productNumber = deptMapper.updateDept(dept);
        // 先删除组织的产品数据
        deptMapper.deleteProductDept(dept.getDeptId());
        // 新增组织产品中间表数据
        batchInsertDepart(dept,productNumber);
        return productNumber;
    }

    /**
     * 根据组织ID查询信息
     *
     * @param deptId 组织ID
     * @return 组织信息
     */
    @Override
    public SysDept selectDeptById(Long deptId)
    {
        return deptMapper.selectDeptById(deptId);
    }

    /**
     * 校验组织名称是否唯一
     *
     * @param dept 组织信息
     * @return 结果
     */
    @Override
    public String checkDeptNameUnique(SysDept dept)
    {
        Long deptId = StringUtils.isNull(dept.getDeptId()) ? -1L : dept.getDeptId();
        SysDept info = deptMapper.checkDeptNameUnique(dept.getDeptName());
        if (StringUtils.isNotNull(info) && info.getDeptId().longValue() != deptId.longValue())
        {
            return UserConstants.DEPT_NAME_NOT_UNIQUE;
        }
        return UserConstants.DEPT_NAME_UNIQUE;
    }

    /**
     * 校验组织是否有数据权限
     *
     * @param deptId 组织id
     */
    @Override
    public void checkDeptDataScope(Long deptId)
    {
        if (!SysUser.isAdmin(ShiroUtils.getUserId()))
        {
            SysDept dept = new SysDept();
            dept.setDeptId(deptId);
            List<SysDept> depts = SpringUtils.getAopProxy(this).selectDeptList(dept);
            if (StringUtils.isEmpty(depts))
            {
                throw new ServiceException("没有权限访问组织数据！");
            }
        }
    }

    /**
     * 查询产品列表（供多选框使用）
     * @return 产品下拉框数据集合
     */
    @Override
    public List<ProductCheckbox> selectProductAll() {
        return deptMapper.selectProductAll();
    }

    /**
     * 查询产品列表（供多选框使用）(修改)
     * @return
     */
    @Override
    public List<ProductCheckbox> selectEditProductAll(Long deptId) {
        // 查询选中的产品数据
        List<String> list = deptMapper.selectCheckedProducts(deptId);
        // 查询所有产品数据
        List<ProductCheckbox> productCheckboxesAll = deptMapper.selectProductAll();
        for (String checkedProduct : list) {
            for (ProductCheckbox productCheckbox : productCheckboxesAll) {
                if(StringUtils.isNotBlank(productCheckbox.getId())){
                    // 如果两个id相等，就将勾选状态改为true
                    if(productCheckbox.getId().equals(checkedProduct)){
                        productCheckbox.setFlag(true);
                    }
                }
            }
        }
        return productCheckboxesAll;
    }

    @Override
    public List<SysDept> getAllDept() {
        return deptMapper.getAllDept();
    }
}
